Transactions for an application domain manager

ABSTRACT

Through one or more transaction calls, an application domain manager enables a host application to create, initialize, customize, and otherwise manage an isolation construct within the application.

DRAWINGS

The detailed description refers to the following drawings.

FIG. 1 shows a network environment in which examples of application domain managers may be implemented.

FIG. 2 shows an example hosting execution environment in which application domain managers may be implemented.

FIG. 3 shows an example processing flow associated with implementing an application domain manager.

FIG. 4 shows an example processing flow further to the example processing flow of FIG. 3.

DETAILED DESCRIPTION

Managing application domains within a process is described herein.

An application domain may be regarded as a construct within an execution environment that is a unit of isolation for a process. More particularly, the isolation construct may enable the code executed therein to be loaded from a specified source; the isolation construct may be aborted independent of other such isolation constructs; and processing within the isolation construct may be isolated so that a fault occurring therein does not affect other isolation constructs within the process. In other words, the effects of processing within an isolation construct are not visible to concurrently-running constructs until the overall process is made permanent. Further, for the sake of consistency, the discussion hereafter refers to “applications” and “processes,” both of which may encompass any one of, at least, software programs, and applications (e.g., SQL), either singularly or in combination.

An example of an execution environment in which an application domain manager may be implemented is a runtime execution environment. Examples of runtime execution environments may include: Visual Basic runtime execution environment; Java® Virtual Machine runtime execution environment that is used to run, e.g., Java® routines; or Common Language Runtime (CLR) to compile, e.g., Microsoft .NET™ applications into machine language before executing a calling routine.

FIG. 1 shows an example of a network environment in which application domain managers may be implemented. More particularly, any one of client device 105, server device 110, and “other” device 115 may be capable of hosting an execution environment in which constructs within an application or process may be customized and controlled by application domain implementation 120, as described herein. Client device 105, server device 110, and “other” device 115 may be communicatively coupled to one another through network 125.

Client device 105 may be at least one of a variety of conventional computing devices, including a desktop personal computer (PC), workstation, mainframe computer, Internet appliance, set-top box, and gaming console. Further, client device 105 may be at least one of any device that is capable of being associated with network 125 by a wired and/or wireless link, including a personal digital assistant (PDA), laptop computer, cellular telephone, etc. Further still, client device 105 may represent the client devices described above in various quantities and/or combinations thereof. “Other” device 115 may also be embodied by any of the above examples of client device 105.

Server device 110 may provide any of a variety of data and/or functionality to client device 105 or “other” device 115. The data may be publicly available or alternatively restricted, e.g., restricted to only certain users or only if an appropriate subscription or licensing fee is paid. Server device 110 is at least one of a network server, an application server, a web blade server, or any combination thereof. Typically, server device 110 is any device that is the source of content, and client device 105 is any device that receives such content either via network 125 or in an off-line manner. However, according to the example implementations described herein, server device 105 and client device 110 may interchangeably be a sending host or a receiving host. “Other” device 115 may also be embodied by any of the above examples of server device 110.

“Other” device 115 may further be any device that is capable of hosting an execution environment in which constructs within an application or process may be customized and controlled by application domain implementation 120 according to one or more of the example implementations described herein. That is, “other” device 115 may be any software-enabled computing or processing device that is capable of managing one or more isolation constructs within at least one application, program, function, or other assemblage of programmable and executable code, in either of a runtime execution environment or some other hosting execution environment. Thus, “other” device 115 may be a computing or processing device having at least one of an operating system, an interpreter, converter, compiler, or runtime execution environment implemented thereon. These examples are not intended to be limiting in any way, and therefore should not be construed in that manner.

Network 125 represents any of a variety of conventional network topologies, which may include any wired and/or wireless network. Network 125 may further utilize any of a variety of conventional network protocols, including public and/or proprietary protocols. For example, network 125 may include the Internet, an intranet, or at least portions of one or more local area networks (LANs).

Data source 130 may represent any one of a variety of conventional computing devices, including a desktop personal computer (PC), that is capable of customizing and controlling (i.e., managing) one or more isolation constructs (e.g., application domains) within an application, program, function, or other assemblage of programmable and executable code. Alternatively, data source 130 may also be any one of a workstation, mainframe computer, Internet appliance, set-top box, gaming console, personal digital assistant (PDA), laptop computer, cellular telephone, etc., that is capable of transmitting at least a portion of an application, program, or function to another work station. Further, although data source 130 may be a source of code for the application, program, or function, for at least the purpose of explaining one or more examples of application domain manager implementation 120, data source 130 may be regarded as at least the source of an application domain manager or an identifier thereof. Regardless of the implementation, the application domain manager, or identity or expression thereof, may be transmitted from data source 130 to any of devices 105, 110, and 115 as part of an on-line notification via network 125 or as part of an off-line notification.

FIG. 2 shows an example hosting execution environment 200 for application domain manager implementation 120.

Operating system (OS) 205 may have host application 210 running thereon. In turn, managed code execution environment 215 (e.g., runtime execution environment) may provide one or more routines for host application 210 to perform properly on OS 205 because host application 210 may require another system in order to execute. Thus, host application 210 may call one or more routines from execution environment 215, and the routines called from execution environment 215 may call one or more appropriate routines from OS 205.

Managed code execution environments have been developed to enhance the reliability of software execution on a growing range of processing devices including servers, desktop computers, laptop computers, and a host of mobile processing devices. More particularly, runtime execution environments may provide a layer of abstraction and services to an application running on a processing device, and further provide such an application with capabilities including error handling and automatic memory management.

Domain manager 220, which may run on managed code execution environment 215, may be an extensible class (i.e., user-defined data type) that enables host application 210 (FIG. 2) to manage isolation constructs (i.e., application domains) therein. Thus, domain manager 220 may enable and manage transactions between, e.g., host application 210 and execution environment 215, whereby the transactions include processing within an application domain. More particularly, transactions group operations together into a single atomic operation, that is, an operation of which the results of the individual operations stand or fall together.

The transactions managed by domain manager 220 may be implemented by utilizing one or more application program interfaces (API) that are compatible with APIs of various system architectures. More particularly, the APIs implemented by domain manager 220 may be capable of creating new application domains within a process and customizing a newly created application domain, typically before managed code is executed in the new domain. That is, the APIs may be capable of managing (i.e., at least one of controlling and customizing) application domains further to the specifications provided by a manifest of a corresponding application or process. Further, one or more of the APIs implemented by domain manager 220 may provide additional interfaces and methods to enable other APIs to participate in the execution of managed code in managed code execution environment 215 (FIG. 2).

APIs implemented by domain manager 220 (FIG. 2) are listed and described below. The nomenclature for the APIs listed and described below is provided for descriptive purposes, and are intended as non-limiting examples.

AppDomainManager may refer to a class of which instantiations enable host application 210 (FIG. 2) to create, customize, and otherwise manage new application domains (i.e., isolation construct) within an application or process. Domain manager 220 may be a custom manager, which may be implemented by host application 210 or, alternatively, may be derived by an instantiation of the default AppDomainManager provided by the execution environment (e.g., CLR).

ApplicationActivator may refer to an API of the AppDomainManager class that enables host application 210 to initialize, customize, or otherwise manage activation of extensions and additions (i.e., “add-ins”) in a newly created application domain. ApplicationActivator may permit one or more add-ins to be activated in a same application domain or, alternatively, may require an activation of an add-in to proceed to a different domain. Activation, security, and initialization parameters for an add-in may be specified in a manifest corresponding to the add-in. The manifest may specify a default entry point to initialize the add-in or to specify a default assembly or type name to be activated as part of the add-in activation. ApplicationActivator may consider host-specific requirements, as well as requirements of the add-in that may be specified in the manifest, when activating the add-in.

HostExecutionContextManager may refer to an API of the AppDomainManager class that enables host application 210 to direct, customize, or otherwise manage the flow of information relevant to a logical thread of execution across asynchronous calls. More particularly, the HostExecutionContextManager class may refer to an ExecutionContext sub-class of which instantiations include, at least, a security context, a call context, a synchronization context, a localization context, and a transaction context.

HostRemotingManager may refer to an API of the AppDomainManager class that enables host application 210 to direct, customize, manage, or otherwise participate in cross-application domain calls. That is, an instantiation of the HostRemotingManager API may participate in calls that enter and leave one or more application domains.

HostSecurityManager may refer to an API of the AppDomainManager class that enables host application 210 to direct, customize, or otherwise manage security settings for a newly created application domain.

AppDomainManager.CreateDomain may refer to a customizable API of the AppDomainManager class that delegates a call to newly create an application domain. In particular, AppDomainManager.CreateDomain may delegate one or more calls to a AppDomainManager.CreateDomainHelper API that actually creates application domain.

AppDomainManager.CreateDomainHelper may refer to an API of the AppDomainManager class that handles the actual creation of an application domain. A description of an example procedure for creating such an application domain is as follows.

In particular, when CreateDomainHelper is called for activation of an add-in activation, the add-in may be verified by calling a further API of the AppDomainManager class e.g., HostSecurityManager.DetermineApplicationTrust, which may return a persisted verification result. If a decision has not been persisted, HostSecurityManager may call yet another API of the AppDomainManager class, e.g., TrustManager, to obtain a run/no-run decision for the application to be created. If a no-run decision is returned, activation of the add-in may fail. Otherwise, activation of the add-in may proceed.

A subsequent call, which may be the next call when CreateDomainHelper is called for activation of an add-in or a first call in the alternative, is to execution environment 215 (FIG. 2) with arguments (i.e., AppDomainSetup parameters) to newly create an application domain. Execution environment may set up data structures for the application domain to be created, and transition the data structures into the new application domain.

A type of AppDomainManager for a new application domain may then be determined. More particularly, according to one example, if a default domain manager is specified by host application 210, an instance of the default domain manager may be created. According to another example, an instance of AppDomainManager that is bootstrapped to the startup of host application 210 may be created. Alternatively, if CreateDomain is called for activating an add-in, as described above, then an appropriate domain manager for the add-in may be called. According to yet another alternative example, a default AppDomainManager may be implemented if no other implementation is specified or otherwise provided.

Execution environment 215 may then proceed to verify that the selected AppDomainManager is able to support the type/API that is expected therefrom. Execution environment 215 may further verify that AppDomainManager is able to satisfy security requirements expected therefrom, as well as verify that AppDomainManger satisfies various requirements (e.g., security) of host application 210.

AppDomainManager may then be instantiated to thus enable domain manager 220 (FIG. 2) to configure and manager the newly created application domain.

The newly created application domain may then be initialized. Execution environment 215 may call into AppDomainManager.InitializeNewDomain to allow the AppDomainManager to configure the newly created application domain. To this end, execution environment 215 may also pass in set up parameters that are passed in to the CreateDomain helper API by an original caller. An implementation of InitializeNewDomain for a default AppDomainManager may not be required to make any call.

Alternatively, a custom AppDomainManager.InitializeNewDomain may be called to set up a new application domain in a customized manner. In that event, custom AppDomainManager may also call a further AppDomainManager API (i.e., InitializationFlags) to indicate to execution environment 215 a request to register a current AppDomainManager with host application 210 because a custom AppDomainManager may typically implement corresponding interfaces to be accessible from host application 210.

In the event that AppDomainManager is an add-in activation, then a further API of the AppDomainManager may initialize an ActivationContext property for the current domain of the add-in. ActivationContext may serve to uniquely identify the add-in and, further, to provide access to details and descriptions pertaining to the add-in, including the corresponding manifest. ActivationContext may also be passed through as a parameter for AppDomainSetup to CreateDomainHelper.

A subsequent call may be made to a further API of the AppDomainManager, i.e., AppDomainManager.ApplicationActivor, to thereby enable host application 210 to supply a custom activator for the newly created application domain. This activator may be used to manage further activations initiated from the newly created application domain.

A subsequent call may be made to a further API of the AppDomainManager, i.e., AppDomainManager.HostExecutionContextManager, to thereby enable host application 210 to participate in the flow of ExecutionContexts, that is, to direct, customize, or otherwise manage the flow of information relevant to a logical thread of execution across asynchronous calls in the newly created application domain.

According to at least one example, a subsequent call may be made to a further API of the AppDomainManager, i.e., AppDomainManager.RemotingManager, to thereby enable host application 210 to participate in cross-application domain calls, that is, to direct, customize, manage, or otherwise participate in cross-application domain calls corresponding to the newly created application domain.

A further call may be made to a further API of the AppDomainManager, i.e., AppDomainManager.SecurityManager, to thereby enable host application 210 to participate in setting the security parameters for the newly created application domain to be created, that is, to direct, customize, or otherwise manage security settings for a newly created application domain.

Calls to further APIs of the AppDomainManager may include: a call to HostSecurityManager.GetDomainPolicy to obtain a security policy for an existing application domain; a call to HostSecurityManager.ProvideEvidence to thereby enable host application 210 to supply evidence for a current application domain.

In the event of an add-in activation, a further call may be to repeat the verification process for the add-in, i.e., a repeat call to HostSecurityManager.DeterminApplicationTrust to determine whether a current instance of AppDomainManager allows the add-in to be activated. If the result is a no-run decision, the add-in activation may not proceed.

Accordingly, by the calls described above, in various orders and combinations that may include or exclude one or more thereof, AppDomainManager has newly created an application domain and configured the application domain appropriately. If the application domain is for an add-in, a call may be made to a still further API of the AppDomainManager, i.e., ApplicationActivator.CreateInstance, to complete the activation.

The newly created application domain may then be initialized. An implementation of InitializeNewDomain for a default AppDomainManager may not be required to make any call.

Alternatively, a custom AppDomainManger.InitializeNewDomain may be called to set up the new application domain in a customized manner. That is, the new application domain may be configured according to specific needs or requests corresponding to host application 210. In that event, custom AppDomainManager may also call a further AppDomainManager API, i.e., InitializationFlags, to thereby enable execution environment 215 to register the Com Collable Wrapper (CCW) of the current AppDomainManager with host application 210 because a custom AppDomainManager may typically implement its own interfaces to be accessible from host application 210. More particularly, CCW may be registered so that a managed AppDomainManager may be called from host application 210.

HostRemotingManager may refer to a class of which instantiations in execution environment 215 enable host application 210 (FIG. 2) to create, customize, manage, and otherwise participate in remoting calls across one or more application domains that are newly created as described above in correspondence with the AppDomainManager class.

EnterAppDomain may refer to an API of the HostRemotingManager class that enables a call in host application 210 to enter an intended, i.e., target, application domain from a source application domain.

LeaveAppDomain may refer to an API of the HostRemotingManager class that enables a call in host application 210 to unwind out of the aforementioned target application domain upon completion of the cross-application domain call.

ReverseEnter may refer to an API of the HostRemotingManager class that enables a call in host application 210 to enter the source application domain while returning from a cross-application domain call.

ReverseLeave may refer to an API of the HostRemotingManager class that enables a call in host application 210 to enter the target application domain when a cross-application domain call leaves the source domain.

HostSecurityManager may refer to a class of which instantiations enable host application 210 (FIG. 2) to create, customize, manage, and otherwise participate in setting security policy in an application domain.

DomainPolicy may refer to an API of the HostSecurityManager class that enables host application 210 to supply a security policy for a newly created application domain.

ProvideAppDomainEvidence may refer to an API of the HostSecurityManager class that enables host application 210 to provide evidence, i.e., input arguments corresponding to security policy, to a newly created application domain.

ProvideAssemblyEvidence may refer to an API of the HostSecurityManager class that enables host application 210 to choose to extend or reduce evidence, i.e., input arguments, that may be utilized by execution environment 215 for loading an assembly to host application 210.

DetermineApplicationTrust may refer to an API of the HostSecurityManager class that enables host application 210 to determine a level of trust accorded to a calling application domain and, either singularly or in combination therewith, determine whether an add-in activation may proceed from or into the current application domain.

The classes and corresponding APIs described above are non-limiting examples that may implemented by domain manager 220 (FIG. 2). As stated previously, the nomenclature for the aforementioned classes and APIs is provided for descriptive purposes, and should not be considered to be restrictive in any way.

FIG. 3 shows example processing flow 300 associated with implementing an application domain manager. Processing flow 300 may be executed utilizing the classes and corresponding APIs described above in connection with FIG. 2. However, such classes and APIs are provided as examples only, and are in no way limiting of the implementations described herein.

Application code 305 may incorporate at least portions of host application 210 (FIG. 2) including, but not limited to, a manifest that includes, e.g., activation, security, and initialization parameters for an application domain.

Application domain manager 310 may be a data structure that is provided as part of application code 305 or as a separate code entity. Further, application domain manager 310 may further incorporate certificate 315 that includes permissions desired, or even required, for application domain manager 310 to manage an application domain in correspondence with application code 305.

Block 320 may represent a verification, performed in execution environment 315 (FIG. 2) of the, e.g., activation and initialization functionalities supported by application domain manager 310. The verification may be performed by measuring the parameters provided in a manifest included in application code 305 against those provided by application domain manager 310. According to at least one alternative example, the manifest of host application 210 may be provided by a separate medium or even by an off-line transmission.

Block 325 may represent a further verification of a security policy supported by application domain manager 310. The verification may be performed by measuring the security policy set forth in the manifest of application code 305 against the security policy provided by application domain manager 310. According to at least one alternative example, the manifest of host application 210 may be provided by a separate medium or even by an off-line transmission. According to even further examples, the verifications occurring at blocks 320 and 325 may be performed in an inverse order or even in combination with each other.

Block 330 may represent the management of an application domain, subsequent to positive verifications at blocks 320 and 325. That is, at block 325, in accordance with a data structure (i.e., contract) provided by application domain manager 310 to specify at least, e.g., activation, security, and initialization functionalities of application domain manager 310, a newly created application domain may be initialized. Further, the functionalities to be implemented by application domain manager 310 may be customized herein.

Decision 335 may represent a determination made by host application 210 of the existence of sub-contracts within application domain manager 310. That is, within a newly created and initialized application domain, one or more application domains may be created and initialized, as specified.

Positive decision 335 may return processing 300 back to blocks 320 and 325 for verification of the compatibility and security of the sub-contracted application domain.

Negative decision 335 may advance processing 300 to the execution of managed code within the one or more newly created and initialized application domains in host application 210.

FIG. 4 shows example processing flow to further describe block 330 of FIG. 3.

Block 405 may represent the creation of an application domain specified or requested by, e.g., application domain manager 310, by an instantiation of AppDomainManager. The creation of an application domain may further be specified or requested by execution environment 215.

Block 410 may represent a selection of the manager of the newly created application domain as specified or requested by application domain manager 310, i.e., by an instantiation of AppDomainManager.

Block 415 may represent a verification of the security of the managed code of host application 210 to be executed in the newly created application domain. The verification may be made against the security parameters of the AppDomainManager class.

Block 420 may represent a configuration or management (i.e., customization) of the newly application domain. That is, upon a positive verification of the security of the managed code of host application 210, the application may be customized to implement only desired functionalities, in anticipation of the execution of managed code at node 235.

Accordingly, an application domain may be managed by customized parameters.

Various modules and techniques may be described herein in the general context of computer-executable instructions, such as program modules, executed by one or more computers or other devices. Generally, program modules include routines, programs, objects, components, data structures, etc. for performing particular tasks or implement particular abstract data types. Typically, the functionality of the program modules may be combined or distributed as desired in various embodiments.

An implementation of these modules and techniques may be stored on or transmitted across some form of computer readable media. Computer readable media can be any available media that can be accessed by a computer. By way of example, and not limitation, computer readable media may comprise “computer storage media” and “communications media.”

“Computer storage media” includes volatile and non-volatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules, or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by a computer.

“Communication media” typically embodies computer readable instructions, data structures, program modules, or other data in a modulated data signal, such as carrier wave or other transport mechanism. Communication media also includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. As a non-limiting example only, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared, and other wireless media. Combinations of any of the above are also included within the scope of computer readable media.

Reference has been made throughout this specification to “one embodiment,” “an embodiment,” or “an example embodiment” meaning that a particular described feature, structure, or characteristic is included in at least one embodiment of the present invention. Thus, usage of such phrases may refer to more than just one embodiment. Furthermore, the described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

One skilled in the relevant art may recognize, however, that the invention may be practiced without one or more of the specific details, or with other methods, resources, materials, etc. In other instances, well known structures, resources, or operations have not been shown or described in detail merely to avoid obscuring aspects of the invention.

While example embodiments and applications of the present invention have been illustrated and described, it is to be understood that the invention is not limited to the precise configuration and resources described above. Various modifications, changes, and variations apparent to those skilled in the art may be made in the arrangement, operation, and details of the methods and systems of the present invention disclosed herein without departing from the scope of the claimed invention. 

We claim:
 1. One or more computer-readable storage media storing instructions comprising a runtime execution environment that executes managed code in virtual machines, the runtime execution environment implementing one or more object classes implementing interfaces in the virtual machine environment, wherein the runtime execution environment itself implements the one or more object classes such that they are provided as part of the runtime execution environment and are available prior to any application or applet running in the runtime execution environment, the interfaces configured to be used by any arbitrary application being executed as managed code by the virtual machine environment, the interfaces implemented by the one or more objects comprising: one or more application program interfaces (APIs) provided by a domain manager object instance that is/are invoked by the arbitrary application to create concurrently executing application domain object instances comprising respective object instances in the virtual machine runtime execution environment under the control of the arbitrary application by use of the domain manager object instance, the application domain object instances comprising instances of an application domain object class natively implemented by the runtime execution environment, the domain manager object instance comprising an instance of a class natively implemented by the runtime execution environment, the domain manager object instance executing in the runtime execution environment and comprising an instance of a class natively implemented by the runtime execution environment and instantiated by the arbitrary application, where the arbitrary application further invokes the one or more APIs of the domain manager object instance to manage the application domain object instances, and where portions of managed code of the arbitrary application concurrently execute within the application domain object instances independently and in isolation such that faults and processing occurring in one application domain object instance does not affect the execution of the managed code within the other application domain object instances, wherein the one or more APIs of the domain manager object include methods that when invoked perform communication with a domain manager object instantiated by another application.
 2. One or more computer-readable storage media according to claim 1, wherein at least one of the one or more APIs to manage the application object instances is/are extensible by the arbitrary application.
 3. One or more computer-readable storage media according to claim 1, wherein the one or more APIs to manage the application domain object instances includes a call to initialize an application domain object instance.
 4. One or more computer-readable storage media according to claim 1, wherein the one or more APIs to manage the application domain object instances includes a call to activate an add-in to an application domain object instance.
 5. One or more computer-readable storage media according to claim 1, wherein the one or more APIs to manage the application object instances includes a call to customize a security policy of an application domain object instance.
 6. One or more computer-readable storage media according to claim 1, wherein the one or more APIs to manage the application domain object instances include a call to manage an execution context of an application domain object instance.
 7. One or more computer-readable storage media according to claim 1, wherein the one or more APIs to manage the application object instances includes a call to participate in cross-application domain calls that enter and leave an application domain object instance of the arbitrary application and correspondingly enter and leave an application domain object instance of another application, the application domain object instance of the other application comprising an instance of the application domain object class.
 8. A method performed by a virtual machine execution environment for managing and executing managed code, the method being performed by one or more processors, the method comprising: receiving a call to launch an application, the application comprising any arbitrary application comprised of arbitrary managed coded executed by the virtual machine execution environment; transmitting calls to create an application domain manager object that is an instance of an application domain manager class natively implemented by the virtual machine execution environment such that the application domain manager class is available to all applications to be executed by the virtual machine execution environment, the application domain manager object implementing a first application program interface (API); transmitting calls to a method of the first API of the application domain manager object to create concurrently executing application domain objects within the application, an application domain object comprising an instance of an application domain class natively implemented by the virtual machine execution environment, the application domain object comprising a second API; and transmitting at least one call to the application domain manager object to manage the application domain objects, the managing comprising controlling and configuring the application domain objects, where each application domain manager object is created before it executes a portion of the application's managed code, where each concurrently executing application domain object executes independently of and in isolation from other application domain objects of the application such that an application domain object may be aborted independent of the other concurrently executing application domain objects and a fault occurring in one application domain object of the application does not affect the execution of the application's managed code in other concurrently executing application domain objects within the application.
 9. A method according to claim 8, wherein the at least one call to manage the application domain objects includes a call to create an application domain object that executes within another application domain object.
 10. A method according to claim 8, wherein the at least one call to manage the application domain objects includes a call to configure an application domain object.
 11. A method according to claim 8, wherein the at least one call to manage the application domain objects includes a call to activate an add-in package specified in a manifest of the application.
 12. A method according to claim 8, wherein the at least one call to manage the application domain objects includes a call to configure security settings of an application domain object.
 13. A method according to claim 8, wherein the at least one call to manage the application domain objects includes a call to manage a synchronization context of an application domain object.
 14. A method according to claim 8, wherein the at least one call to manage the application domain objects is extensible.
 15. A method according to claim 8, wherein the at least one call to manage the application domain objects is called by a host of the application domain objects.
 16. A method according to claim 8, wherein the at least one call to manage the application domain object instances is called by a hosting execution environment.
 17. One or more computer-readable storage media according to claim 1, wherein one of the application domain objects enables transactions between the arbitrary application and the virtual machine environment such that operations of the arbitrary application stand or fall together as a single atomic operation.
 18. One or more computer-readable storage media according to claim 1, wherein the application domain manager object instance manages calls between two application domain object instances.
 19. A method according to claim 8, wherein the application domain manager object enables transactions between the application and the virtual machine environment such that operations of the application stand or fall together as a single atomic operation.
 20. A method according to claim 8, wherein the application domain manager object manages calls between application domain objects.
 21. A computing device with a processor, the device comprising: a managed code environment executing on the processor that provides virtual machine environments that execute managed code of applications, the managed code environment configured to execute, as managed code, an application domain manager object, where the application domain manager object is an object that is an instance of an application domain manager class natively implemented by the managed code environment such that any arbitrary application running in the managed code environment can instantiate an object instance of the application domain manager class, the application domain manage object comprising an application programming interface (API) comprised of methods thereof; the application domain manager object, which is instantiated and used by one of the applications to construct application domain objects; the application domain objects, which are controlled and configured by the application invoking methods of the application domain manager object, the application domain objects comprising object instances of an application domain class implemented by the managed code environment and available for arbitrary applications executing therein and providing execution isolation, wherein portions of managed code of the application concurrently execute in the application domain objects in isolation such that execution of a portion of managed code in one application domain object is isolated from execution of a portion of managed code in another application domain, the execution in one of the application domain object not affecting the execution in another application domain object, the application domain manager including methods that allow applications in the managed code environment that are isolated within respective instances of the application domain manager class to send each other messages.
 22. A computing device according to claim 21, wherein the application domain manager object manages calls across application domain objects as instructed by the application.
 23. A computing device according to claim 21, wherein an application domain object provides transactioning of operations between the application and the managed code environment such that groups of operations of the application stand or fall together as a single atomic operation.
 24. One or more computer readable storage media storing a runtime execution environment that executes managed code in virtual machines, the runtime execution environment comprising: an application domain manager object class comprising a class natively implemented by the runtime execution environment such that any application being executed by the runtime execution environment may instantiate an object instance of the application domain manager object class, the application domain manager object class comprising methods, wherein when an application being executed by the runtime execution environment instantiates an object instance of the application domain manager object class, the application an application domain object class comprising a class natively implemented by the runtime execution environment such that any application being executed by the runtime execution environment can instantiate a plurality of concurrently executing object instances of the application domain object class by invoking a method of an object instance of the application domain manager object class, wherein an object instance of application domain object class executes managed code from a specified source, and wherein the concurrently executing object instances of the application domain object class execute in isolation with respect to each other and faults and processing in one object instance of the application domain object class do not affect the other object instances of the application domain object class, and wherein the application uses one or methods of the object instance of the application domain manager class to manage the object instances of the application domain object class, the managing including controlling and configuring the object instances of the application domain object class. 